home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / gfx / 3d / Skulpt_src.lha / sKulpt-src / Ami-Stuff.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-10-05  |  26.5 KB  |  867 lines
  1. #define STRICT
  2.  
  3. // Includes standard Windows
  4. #include <windows.h>
  5. #include <windowsx.h>
  6. #include <time.h>
  7. #include <stdlib.h>
  8. #include <malloc.h>
  9. #include <memory.h>
  10. #include <stdio.h>
  11.  
  12. #include    <stdarg.h>
  13.  
  14. // Includes D3D
  15. #define  D3D_OVERLOADS
  16. #include <ddraw.h>
  17. #include <d3d.h>
  18. #include <d3dx.h>
  19.  
  20. // Includes utilitaires D3D
  21. #include "d3dmath.h"
  22. #include "d3dutil.h"
  23. #include "D3DEnum.h"
  24.  
  25. // Ids Resources
  26. #include "resource.h"
  27.  
  28. // Constantes
  29. #include "const.h"
  30.  
  31. // Types
  32. #include "types.h"
  33.  
  34. // Variables globales projet
  35. #include "vars.h"
  36.  
  37. // Prototypes fonctions autres modules
  38. #include "proto.h"
  39.  
  40. // Macros
  41. #include "macros.h"
  42.  
  43. // Spécifiques module
  44. #include "libraries/gadtools.h"
  45. #include "menusample.h"
  46. #include <clib/diskfont_protos.h>
  47.  
  48. #ifdef __PPC__
  49. #include <powerpc/powerpc.h>
  50. #include <clib/powerpc_protos.h>
  51. #endif
  52.  
  53. #ifdef __PPC__
  54. char sVersion[] = "$VER: sKulpt W3D alpha 28 04-Oct-2000 (W3D/PPC) - stephane.guillard@steria.fr";
  55. #else
  56. char sVersion[] = "$VER: sKulpt W3D alpha 28 04-Oct-2000 (W3D/060) - stephane.guillard@steria.fr";
  57. #endif
  58.  
  59. char s3DTitle[80];
  60.  
  61. NewWindow NWS2D =
  62. {
  63.     0, 0,
  64.     30, 30,
  65.     0, 1,
  66.     IDCMP_NEWSIZE,  // Seul le newsize est activé à la création, mais ensuite l'IDCMP est modifié pour prise en compte de tous les autres messages
  67.     WFLG_DEPTHGADGET | WFLG_SIZEBBOTTOM | WFLG_DRAGBAR | WFLG_SIZEGADGET | WFLG_SIMPLE_REFRESH,
  68.     NULL,
  69.     NULL,
  70.     NULL,
  71.     NULL,
  72.     NULL,
  73.     20, 20,
  74.     ~0, ~0,
  75.     CUSTOMSCREEN
  76. };
  77.  
  78. NewWindow NWS3D =
  79. {
  80.     0, 0,
  81.     30, 30,
  82.     0, 1,
  83.     NULL, // Le filtre IDCMP de la fenêtre 3D est défini après l'avoir redimensionnée pour éviter de redim backbuf+zbuf au démarrage
  84.     WFLG_DEPTHGADGET | WFLG_SIZEBBOTTOM | WFLG_DRAGBAR | WFLG_SIZEGADGET | WFLG_SIMPLE_REFRESH,
  85.     NULL,
  86.     NULL,
  87.     NULL,
  88.     NULL,
  89.     NULL,
  90.     20, 20,
  91.     ~0, ~0,
  92.     CUSTOMSCREEN
  93. };
  94.  
  95. NewWindow NWSMenu =
  96. {
  97.     0, 0,
  98.     30, 30,
  99.     0, 1,
  100.     IDCMP_VANILLAKEY | IDCMP_CLOSEWINDOW | IDCMP_MENUPICK,
  101.     WFLG_ACTIVATE | WFLG_DEPTHGADGET | WFLG_SIZEBBOTTOM | WFLG_DRAGBAR | WFLG_SIZEGADGET | WFLG_CLOSEGADGET | WFLG_SIMPLE_REFRESH | WFLG_NOCAREREFRESH,
  102.     NULL,
  103.     NULL,
  104.     NULL,
  105.     NULL,
  106.     NULL,
  107.     20, 20,
  108.     ~0, ~0,
  109.     CUSTOMSCREEN
  110. };
  111.  
  112. HMENU hMenu = NULL;
  113.  
  114. void vWarpInfo(void)
  115. {
  116.     ULONG lRes;
  117.     char cBuf[255];
  118.  
  119.     W3D_Driver **hDriver = W3D_GetDrivers();
  120.  
  121.     while (*hDriver)
  122.     {
  123.         sprintf(cBuf, "Driver [%s] : fmt 0x%lX ", hDriver[0] -> name, hDriver[0] -> formats);
  124.         strcat(s3DTitle, hDriver[0] -> name); strcat(s3DTitle, "]");
  125.  
  126.         if (hDriver[0] -> swdriver) sprintf(cBuf + strlen(cBuf), "(HEL) ");
  127.         else                        sprintf(cBuf + strlen(cBuf), "(HAL) ");
  128.  
  129.         sprintf(cBuf + strlen(cBuf), "- primitives : ");
  130.         lRes = W3D_QueryDriver(hDriver[0], W3D_Q_DRAW_POINT, W3D_FMT_R5G5B5);
  131.         if (lRes != W3D_NOT_SUPPORTED) sprintf(cBuf + strlen(cBuf), "point ");
  132.  
  133.         lRes = W3D_QueryDriver(hDriver[0], W3D_Q_DRAW_LINE, W3D_FMT_R5G5B5);
  134.         if (lRes != W3D_NOT_SUPPORTED) sprintf(cBuf + strlen(cBuf), "line ");
  135.  
  136.         lRes = W3D_QueryDriver(hDriver[0], W3D_Q_DRAW_TRIANGLE, W3D_FMT_R5G5B5);
  137.         if (lRes != W3D_NOT_SUPPORTED) sprintf(cBuf + strlen(cBuf), "triangle ");
  138.  
  139.         sprintf(cBuf + strlen(cBuf), "- filtres : ");
  140.         lRes = W3D_QueryDriver(hDriver[0], W3D_Q_BILINEARFILTER, W3D_FMT_R5G5B5);
  141.         if (lRes != W3D_NOT_SUPPORTED) sprintf(cBuf + strlen(cBuf), "bilinear ");
  142.  
  143.         lRes = W3D_QueryDriver(hDriver[0], W3D_Q_MMFILTER, W3D_FMT_R5G5B5);
  144.         if (lRes != W3D_NOT_SUPPORTED) sprintf(cBuf + strlen(cBuf), "mipmap");
  145.  
  146.         vTrace(cBuf);
  147.         hDriver++;
  148.     }
  149. }
  150.  
  151. // Simulation PostMessage Windows : dispatcher le message sur la WindowProc en fonction de hWnd
  152. inline int PostMessage(HWND hWnd, int iMsg, WPARAM wParam, LPARAM lParam)
  153. {
  154.     if (hWnd == hWndTop || hWnd == hWndFace || hWnd == hWndRight)
  155.     {
  156.         lrPlanarWndProc(hWnd, iMsg, wParam, lParam);
  157.         return 0;
  158.     }
  159.  
  160.     if (hWnd == hWndPersp)
  161.     {
  162.         lrPerspWndProc(hWnd, iMsg, wParam, lParam);
  163.         return 0;
  164.     }
  165.  
  166.     if (hWnd == hWndMenu)
  167.         lrMenuWndProc(hWnd, iMsg, wParam, lParam);
  168.  
  169.     return 0;
  170. }
  171.  
  172. inline int iDispatchIntuiMessage(HWND wGotMsg, IntuiMessage *iMsg)
  173. {
  174.     APTR iAddress   = iMsg -> IAddress;
  175.     register int
  176.         iClass      = iMsg -> Class,
  177.         iCode       = iMsg -> Code;
  178.     register WORD
  179.         wQualifier  = iMsg -> Qualifier,
  180.         wMouseX     = iMsg -> MouseX,
  181.         wMouseY     = iMsg -> MouseY;
  182.  
  183.     ReplyMsg((struct Message *) iMsg);
  184.  
  185.     switch(iClass)
  186.     {
  187.         case IDCMP_ACTIVEWINDOW :
  188.             if (wGotMsg == hWndTop) lWActive = XDC_WID_TOP;
  189.             if (wGotMsg == hWndFace) lWActive = XDC_WID_FACE;
  190.             if (wGotMsg == hWndRight) lWActive = XDC_WID_SIDE;
  191.             break;
  192.  
  193.         case IDCMP_VANILLAKEY :
  194.             PostMessage(wGotMsg, WM_CHAR, iCode, 0);
  195.             break;
  196.  
  197.         case IDCMP_NEWSIZE :
  198.             PostMessage(wGotMsg, WM_SIZE, 0, (ULONG) wGotMsg -> Width | ((ULONG) wGotMsg -> Height) << 16);
  199.             break;
  200.  
  201.         case IDCMP_MOUSEMOVE:
  202.             if (!PeekSignal(l2DWinSigMask))
  203.                 PostMessage(wGotMsg, WM_MOUSEMOVE, wQualifier, (ULONG) wMouseX & 0x0000FFFF | ((ULONG) wMouseY) << 16);
  204.             break;
  205.  
  206.         case IDCMP_MENUPICK :
  207.             if (iCode != MENUNULL)
  208.                 PostMessage(wGotMsg, WM_COMMAND, (WPARAM) GTMENUITEM_USERDATA(ItemAddress(hMenu, iCode)), (LPARAM) 0);
  209.             break;
  210.  
  211.         case IDCMP_REFRESHWINDOW :
  212.             BeginRefresh(wGotMsg);
  213.             PostMessage(wGotMsg, WM_PAINT, 0, 0);
  214.             EndRefresh(wGotMsg, TRUE);
  215.             break;
  216.  
  217.         case IDCMP_CLOSEWINDOW :
  218.             PostMessage(wGotMsg, WM_CLOSE, 0, 0);
  219.             break;
  220.  
  221.         case IDCMP_MOUSEBUTTONS:
  222.             switch(iCode)
  223.             {
  224.                 case MIDDLEDOWN:
  225.                     wQualifier |= IEQUALIFIER_RCOMMAND;
  226.                 case SELECTDOWN:
  227.                     PostMessage(wGotMsg, WM_LBUTTONDOWN, wQualifier, (ULONG) wMouseX & 0x0000FFFF | ((ULONG) wMouseY) << 16);
  228.                     break;
  229.  
  230.                 case MIDDLEUP:
  231.                 case SELECTUP:
  232.                     PostMessage(wGotMsg, WM_LBUTTONUP, wQualifier, (ULONG) wMouseX & 0x0000FFFF | ((ULONG) wMouseY) << 16);
  233.                     break;
  234.             }
  235.             break;
  236.  
  237.         default :
  238.             vTrace("*** E0034 : Message Class %08lX Code %04X Qualif %04X reçu et ignoré pour fenêtre %s", iClass, iCode, wQualifier, wGotMsg -> Title);
  239.             break;
  240.     }
  241.     return iClass;
  242. }
  243.  
  244. #define mCleanExit(s, l)    \
  245. {                           \
  246.     vTrace(s);              \
  247.     goto l;                 \
  248. }
  249.  
  250. ULONG lFlags, lModeID, lError;
  251.  
  252. int main(int argc, char **argv)
  253. {
  254.     IntuiMessage *iMsg;
  255.     int iClass;
  256.     ULONG lSigTop, lSigFace, lSigRight, lSig3D, lSigMenu, lSignals;
  257.     W3D_Double dZdepth = 0.8;
  258.     TextAttr sTextAttr = {
  259.         "courier.font",
  260.         13,
  261.         NULL, //FSF_ITALIC | FSF_BOLD,
  262.         NULL
  263.     };
  264.     TextFont *hFont;
  265.  
  266.     // Mémoriser notre pointeur de tâche
  267.     hApp = FindTask(NULL);
  268.  
  269.     // Ouvrir les librairies non ouvertes par défaut par les stubs Storm
  270.     GadToolsBase   = OpenLibrary((UBYTE *) "gadtools.library",  39L);
  271.     UtilityBase    = OpenLibrary((UBYTE *) "utility.library",   39L);
  272.     AslBase        = OpenLibrary((UBYTE *) "asl.library",       39L);
  273.     AmigaGuideBase = OpenLibrary((UBYTE *) "amigaguide.library",39L);
  274.     DataTypesBase  = OpenLibrary((UBYTE *) "datatypes.library", 39L);
  275.     IconBase       = OpenLibrary((UBYTE *) "icon.library",      39L);
  276.     DiskfontBase   = OpenLibrary((UBYTE *) "diskfont.library",  39L);
  277.     CyberGfxBase   = OpenLibrary((UBYTE *) "cybergraphics.library", 0L);
  278.     if (!(GadToolsBase && UtilityBase && AslBase && AmigaGuideBase && DataTypesBase && IconBase && CyberGfxBase && DiskfontBase))
  279.         mCleanExit("*** E0035 : librairie manquante, utilisez SnoopDos pour trouver laquelle", _mce_CloseLibs);
  280.  
  281. #ifndef __PPC__
  282.     Warp3DBase     = OpenLibrary((UBYTE *) "Warp3D.library",    3L);
  283.     if (!Warp3DBase)
  284. #else
  285.     Warp3DPPCBase  = OpenLibrary((UBYTE *) "Warp3DPPC.library", 3L);
  286.     if (!Warp3DPPCBase)
  287. #endif
  288.         mCleanExit("*** E0036 : librairie Warp3D v3 manquante", _mce_CloseLibs);
  289.  
  290.     if (!(hFont = OpenDiskFont(&sTextAttr)))
  291.         mCleanExit("*** E0098 : fonte introuvable", _mce_CloseLibs);
  292.  
  293.     // Check for availability of drivers
  294.     lFlags = W3D_CheckDriver();
  295.     if (lFlags & W3D_DRIVER_UNAVAILABLE)
  296.         mCleanExit("*** E0037 : pas de driver Warp3D", _mce_CloseLibs);
  297.  
  298.     // Choisir un mode d'écran compatible Warp3D
  299.     lModeID = W3D_RequestModeTags(
  300.         W3D_SMR_TYPE,       W3D_DRIVER_3DHW,
  301.         W3D_SMR_DESTFMT,    ~W3D_FMT_CLUT,
  302.         TAG_DONE);
  303.  
  304.     if (lModeID == INVALID_ID)
  305.         mCleanExit("*** E0038 : mode écran invalide", _mce_CloseLibs);
  306.                                                                             
  307.     // Ouvrir l'écran selon mode demandé
  308.     if (!(hInst = OpenScreenTags(NULL,
  309.                                       SA_DisplayID,          lModeID,
  310.                                  SA_SharePens,          TRUE,
  311.                                  SA_Title,              (ULONG) sVersion + 6,
  312.                                   SA_Draggable,          FALSE,
  313.                                  SA_Font,               (ULONG) &sTextAttr,
  314.                                   TAG_DONE)))
  315.         mCleanExit("*** E0039 : ouverture écran", _mce_CloseLibs);
  316.  
  317.     NWS2D.Screen = NWS3D.Screen = NWSMenu.Screen = hInst;
  318.     NWSMenu.Width = hInst -> Width; NWSMenu.Height = hInst -> Height;
  319.  
  320.     // Créer la structure de menus GadToolz
  321.     hVi     = GetVisualInfo(hInst, TAG_DONE);                                     
  322.     hMenu   = CreateMenus(mNMenu, GTMN_FrontPen, 0, TAG_DONE);
  323.     LayoutMenus(hMenu, hVi, TAG_DONE);
  324.     
  325.     // Allouer les structures du filerequester
  326.     if (!FSInit())
  327.         mCleanExit("*** E0040 : allocation filerequester", _mce_CloseLibsAndScreenAndVI);
  328.  
  329.     // Allouer les structures du gestionnaire de dialogs
  330.     if (!DLGInit("gfx/sampler.res"))
  331.         mCleanExit("*** E0048 : initialisation ressources", _mce_CloseLibsAndScreenAndVIAndFS);
  332.  
  333.     // Préparer les gadgets
  334.     if (!bPrepareGadgets())
  335.         mCleanExit("*** E0049 : initialisation gadgets", _mce_CloseLibsAndScreenAndVIAndFSAndDlg);
  336.  
  337.     // Initialiser les tableaux d'objets 3D
  338.     vDeleteObjects();
  339.  
  340.     // Se présenter...
  341.     vLogo();
  342.  
  343.     // Créer la fenêtre de menus, y attacher le menustrip et définr son titre
  344.     PostMessage(hWndMenu = OpenWindow(&NWSMenu), WM_CREATE, 0, 0); SetMenuStrip(hWndMenu, hMenu); SetWindowTitles(hWndMenu, sVersion + 6, (UBYTE *) -1);
  345.  
  346.     // Attacher la console de trace à la fenêtre de menus
  347.     if (!InitConsole(hWndMenu))
  348.         mCleanExit("*** E0047 : initialisation console", _mce_CloseLibsAndScreenAndVIAndFSAndDlgAndGads);
  349.  
  350. #ifdef __PPC__  // Taing ça pulse trop aussi ici.
  351.     Delay(50);
  352. #endif
  353.  
  354.     // Charger les textures disponibles
  355.     bLoadTextures();
  356.  
  357.     // Charger la configuration des hints W3D
  358.     bLoadHints();
  359.  
  360.     // Créer les fenêtres 2D, leur envoyer un WM_CREATE, leur attacher la menustrip de la fenêtre menu, leur coller un titre
  361.     PostMessage(hWndTop = OpenWindow(&NWS2D), WM_CREATE, 0, 0); LendMenus(hWndTop, hWndMenu); SetWindowTitles(hWndTop, "Vue de dessus", (UBYTE *) -1); SetDrMd(GetDC(hWndTop), JAM1);
  362.     PostMessage(hWndFace = OpenWindow(&NWS2D), WM_CREATE, 0, 0); LendMenus(hWndFace, hWndMenu); SetWindowTitles(hWndFace, "Vue de face", (UBYTE *) -1); SetDrMd(GetDC(hWndFace), JAM1);
  363.     PostMessage(hWndRight = OpenWindow(&NWS2D), WM_CREATE, 0, 0); LendMenus(hWndRight, hWndMenu); SetWindowTitles(hWndRight, "Vue de droite", (UBYTE *) -1); SetDrMd(GetDC(hWndRight), JAM1);
  364.  
  365.     // Créer la fenêtre 3D etc....
  366. //      PostMessage(hWndPersp = OpenWindow(&NWS3D), WM_CREATE, 0, 0); LendMenus(hWndPersp, hWndMenu);
  367.     hWndPersp = OpenWindow(&NWS3D); LendMenus(hWndPersp, hWndMenu);
  368.  
  369.     // Laisser Intuition flusher son pipe sinon crash...
  370. #ifdef __PPC__  // Taing, ça pulse trop.
  371.     Delay(50);
  372. #else
  373.     Delay(10);
  374. #endif
  375.  
  376.     // Redimensionner les fenêtres (ce qui vide la trace...)
  377.     vRemakeTriview(0L);
  378.  
  379.     // Définir le filtre IDCMP de la fenêtre 3D et lui envoyer un WM_CREATE
  380.     // (seulement maintenant pour éviter qu'elle ne fasse un WM_SIZE lors du redim des fenêtres)
  381.     ModifyIDCMP(hWndPersp, IDCMP_VANILLAKEY | IDCMP_NEWSIZE | IDCMP_REFRESHWINDOW | IDCMP_MENUPICK);
  382.     PostMessage(hWndPersp, WM_CREATE, 0, 0);
  383.  
  384.     // Forcer le rafraichissement complet de la fenêtre 3D
  385.     vForce3DRefresh(XDC_MODE_COMPLET);
  386.  
  387.     // Mettre à jour les checkmarks des menus
  388.     vUpdateMenu();
  389.  
  390.     // Créer le contexte W3D commun aux 3 fenêtres 2D (sans zbuf)
  391.     hW3DC_2D = W3D_CreateContextTags(&lError,
  392.         W3D_CC_MODEID,      lModeID,
  393.         W3D_CC_BITMAP,      (ULONG) (hInst -> RastPort.BitMap),
  394.         W3D_CC_YOFFSET,     0,
  395.         W3D_CC_DRIVERTYPE,  W3D_DRIVER_BEST,
  396.         W3D_CC_DOUBLEHEIGHT, FALSE,
  397.         W3D_CC_FAST,        TRUE,
  398.         TAG_DONE);
  399.  
  400.     if (!hW3DC_2D || lError != W3D_SUCCESS)
  401.     {
  402.         switch(lError)
  403.         {
  404.         case W3D_ILLEGALINPUT:
  405.             vTrace("*** E0041 : paramètres CreateContext()");
  406.             break;
  407.         case W3D_NOMEMORY:
  408.             vTrace("*** E0042 : mémoire insuffisante");
  409.             break;
  410.         case W3D_NODRIVER:
  411.             vTrace("*** E0043 : driver invalide");
  412.             break;
  413.         case W3D_UNSUPPORTEDFMT:
  414.             vTrace("*** E0044 : bitmap incompatible Warp3D");
  415.             break;
  416.         case W3D_ILLEGALBITMAP:
  417.             vTrace("*** E0045 : bitmap mal initialisé");
  418.             break;
  419.         default:
  420.             vTrace("*** E0046 : erreur interne");
  421.         }
  422.         goto _mce_CloseLibsAndScreenAndVIAndWindows;
  423.     }
  424.  
  425.     // Set states pour le contexte 2D
  426.     W3D_SetState(hW3DC_2D, W3D_SCISSOR,             W3D_ENABLE);
  427.     W3D_SetState(hW3DC_2D, W3D_AUTOTEXMANAGEMENT,   W3D_ENABLE);
  428.  
  429.     W3D_SetState(hW3DC_2D, W3D_DITHERING,           W3D_DISABLE);
  430.     W3D_SetState(hW3DC_2D, W3D_GOURAUD,             W3D_DISABLE);
  431.     W3D_SetState(hW3DC_2D, W3D_ZBUFFERUPDATE,       W3D_DISABLE);
  432.     W3D_SetState(hW3DC_2D, W3D_ZBUFFER,             W3D_DISABLE);
  433.     W3D_SetState(hW3DC_2D, W3D_SYNCHRON,            W3D_DISABLE);
  434.     W3D_SetState(hW3DC_2D, W3D_INDIRECT,            W3D_DISABLE);
  435.     W3D_SetState(hW3DC_2D, W3D_TEXMAPPING,          W3D_DISABLE);
  436.     W3D_SetState(hW3DC_2D, W3D_PERSPECTIVE,         W3D_DISABLE);
  437.     W3D_SetState(hW3DC_2D, W3D_BLENDING,            W3D_DISABLE);
  438.     W3D_SetState(hW3DC_2D, W3D_FOGGING,             W3D_DISABLE);
  439.     W3D_SetState(hW3DC_2D, W3D_LOGICOP,             W3D_DISABLE);
  440.     W3D_SetState(hW3DC_2D, W3D_STENCILBUFFER,       W3D_DISABLE);
  441.     W3D_SetState(hW3DC_2D, W3D_DOUBLEHEIGHT,        W3D_DISABLE);
  442.  
  443.     // Hints pour maximiser les performances
  444.     W3D_Hint(hW3DC_2D, W3D_H_TEXMAPPING, W3D_H_FAST);
  445.     W3D_Hint(hW3DC_2D, W3D_H_MIPMAPPING, W3D_H_FAST);
  446.     W3D_Hint(hW3DC_2D, W3D_H_BILINEARFILTER, W3D_H_FAST);
  447.     W3D_Hint(hW3DC_2D, W3D_H_MMFILTER, W3D_H_FAST);
  448.     W3D_Hint(hW3DC_2D, W3D_H_PERSPECTIVE, W3D_H_FAST);
  449.     W3D_Hint(hW3DC_2D, W3D_H_BLENDING, W3D_H_FAST);
  450.     W3D_Hint(hW3DC_2D, W3D_H_FOGGING, W3D_H_FAST);
  451.     W3D_Hint(hW3DC_2D, W3D_H_ANTIALIASING, W3D_H_FAST);
  452.     W3D_Hint(hW3DC_2D, W3D_H_DITHERING, W3D_H_FAST);
  453.     W3D_Hint(hW3DC_2D, W3D_H_ZBUFFER, W3D_H_FAST);
  454.  
  455.     // Afficher les propriétés des drivers Warp installés
  456.     strcpy(s3DTitle,
  457. #ifdef __PPC__
  458.            "Vue 3D [soft T&L (PPC), "
  459. #else
  460.            "Vue 3D [soft T&L (060), "
  461. #endif
  462.           );
  463.     vWarpInfo();
  464.     SetWindowTitles(hWndPersp, s3DTitle, (UBYTE *) -1);
  465.  
  466.     // Préparer les matrices world / view / proj
  467.     hrInitWorld(NULL);
  468.  
  469.     // Finaliser la liste des messages broadcastés pour les fenêtres 2D
  470.     ModifyIDCMP(hWndTop,    IDCMP_ACTIVEWINDOW | IDCMP_VANILLAKEY | IDCMP_NEWSIZE | IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE | IDCMP_REFRESHWINDOW | IDCMP_MENUPICK);
  471.     ModifyIDCMP(hWndFace,   IDCMP_ACTIVEWINDOW | IDCMP_VANILLAKEY | IDCMP_NEWSIZE | IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE | IDCMP_REFRESHWINDOW | IDCMP_MENUPICK);
  472.     ModifyIDCMP(hWndRight,  IDCMP_ACTIVEWINDOW | IDCMP_VANILLAKEY | IDCMP_NEWSIZE | IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE | IDCMP_REFRESHWINDOW | IDCMP_MENUPICK);
  473.  
  474.     // Préparer les masques de signaux pour la boucle de messages
  475.     lSigMenu = 1L << hWndMenu -> UserPort -> mp_SigBit;
  476.     lSigTop = 1L << hWndTop -> UserPort -> mp_SigBit;
  477.     lSigFace = 1L << hWndFace -> UserPort -> mp_SigBit;
  478.     lSigRight = 1L << hWndRight -> UserPort -> mp_SigBit;
  479.     lSig3D = 1L << hWndPersp -> UserPort -> mp_SigBit;
  480.     l2DWinSigMask = lSigTop | lSigFace | lSigRight;
  481.     lSigMask = lSigMenu | l2DWinSigMask | lSig3D;
  482.  
  483.     // Boucle principale de traitement des messages Intuition
  484.     do
  485.     {
  486.         // Attendre un message sur toutes les fenêtres
  487. #ifdef __PPC__
  488.         lSignals = WaitPPC(lSigMask);
  489. #else
  490.         lSignals = Wait(lSigMask);
  491. #endif
  492.         // Traiter tous les messages dans la file de la fenêtre Menus
  493.         if (lSignals & lSigMenu)
  494.             while (iMsg = (struct IntuiMessage *) GetMsg(hWndMenu -> UserPort))
  495.                 iClass = iDispatchIntuiMessage(hWndMenu, iMsg);
  496.       
  497.         // Traiter tous les messages dans la file de la fenêtre Vue de dessus
  498.           if (lSignals & lSigTop)
  499.             while (iMsg = (struct IntuiMessage *) GetMsg(hWndTop -> UserPort))
  500.                 iClass = iDispatchIntuiMessage(hWndTop, iMsg);
  501.  
  502.         // Traiter tous les messages dans la file de la fenêtre Vue de face
  503.         if (lSignals & lSigFace)
  504.             while (iMsg = (struct IntuiMessage *) GetMsg(hWndFace -> UserPort))
  505.                 iClass = iDispatchIntuiMessage(hWndFace, iMsg);
  506.  
  507.         // Traiter tous les messages dans la file de la fenêtre Vue de droite
  508.         if (lSignals & lSigRight)
  509.             while (iMsg = (struct IntuiMessage *) GetMsg(hWndRight -> UserPort))
  510.                 iClass = iDispatchIntuiMessage(hWndRight, iMsg);
  511.  
  512.         // Traiter tous les messages dans la file de la fenêtre Vue 3D
  513.         if (lSignals & lSig3D)
  514.             while (iMsg = (struct IntuiMessage *) GetMsg(hWndPersp -> UserPort))
  515.                 iClass = iDispatchIntuiMessage(hWndPersp, iMsg);
  516.  
  517.         // Traiter tous les messages dans la file de la dlgbox
  518.         if (hWndDlg && (lSignals & (1L << hWndDlg -> UserPort -> mp_SigBit)))
  519.             vProcessDlgMessage();
  520.     }
  521.     // Jusqu'à IDCMP_CLOSEWINDOW (qui ne peut venir que de la fenêtre Menus)
  522.     while (iClass != IDCMP_CLOSEWINDOW);
  523.  
  524.     if (hW3DC_2D) W3D_DestroyContext(hW3DC_2D);
  525.  
  526. _mce_CloseLibsAndScreenAndVIAndWindows:
  527.     // Libérer les entités allouées par les fenêtres en leur envoyant un WM_DESTROY
  528.     if (hWndDlg)    EndDialog(hWndDlg, -1);
  529.     if (hWndTop)    PostMessage(hWndTop,    WM_DESTROY, 0, 0);
  530.     if (hWndFace)   PostMessage(hWndFace,   WM_DESTROY, 0, 0);
  531.     if (hWndRight)  PostMessage(hWndRight,  WM_DESTROY, 0, 0);
  532.     if (hWndPersp)  PostMessage(hWndPersp,  WM_DESTROY, 0, 0);
  533.     if (hWndMenu)   PostMessage(hWndMenu,   WM_DESTROY, 0, 0);
  534.  
  535.     // Détacher la menustrip
  536.     if (hWndTop)    LendMenus(hWndTop, NULL);
  537.     if (hWndFace)   LendMenus(hWndFace, NULL);
  538.     if (hWndRight)  LendMenus(hWndRight, NULL);
  539.     if (hWndPersp)  LendMenus(hWndPersp, NULL);
  540.     if (hWndMenu)   ClearMenuStrip(hWndMenu);
  541.  
  542.     // Refermer la console de trace
  543.     if (hWndMenu)   CloseConsole();
  544.     
  545.     // Fermer les fenêtres
  546.     if (hWndTop)    CloseWindow(hWndTop);
  547.     if (hWndFace)   CloseWindow(hWndFace);
  548.     if (hWndRight)  CloseWindow(hWndRight);
  549.     if (hWndPersp)  CloseWindow(hWndPersp);
  550.     if (hWndMenu)   CloseWindow(hWndMenu);
  551.  
  552.     // Dropper les textures
  553.     vUnLoadTextures();
  554.  
  555. _mce_CloseLibsAndScreenAndVIAndFSAndDlgAndGads:
  556.     // Libérer les gadgets
  557.     vEraseGadgets();
  558.  
  559. _mce_CloseLibsAndScreenAndVIAndFSAndDlg:
  560.     // Libérer les structures File Requester et screenmoderequester et du gestionnaire de console
  561.     DLGClose();
  562. _mce_CloseLibsAndScreenAndVIAndFS:
  563.     FSClose();
  564.  
  565. _mce_CloseLibsAndScreenAndVI:
  566.     // Détruire le menustrip
  567.     FreeMenus(hMenu);
  568.  
  569.     // Libérer le Visual Info Gadtoolz
  570.     FreeVisualInfo(hVi);
  571.  
  572.     // Fermer l'écran s'il s'agit d'un écran custom
  573.     if (lModeID != INVALID_ID)
  574.         CloseScreen(hInst);
  575.  
  576. _mce_CloseLibs:
  577.     // Refermer les librairies
  578.     if (GadToolsBase)   CloseLibrary(GadToolsBase);
  579.     if (UtilityBase)    CloseLibrary(UtilityBase);
  580.     if (AslBase)        CloseLibrary(AslBase);
  581.     if (AmigaGuideBase) CloseLibrary(AmigaGuideBase);
  582.     if (DataTypesBase)  CloseLibrary(DataTypesBase);
  583.     if (IconBase)       CloseLibrary(IconBase);
  584.     if (DiskfontBase)   CloseLibrary(DiskfontBase);
  585.     if (CyberGfxBase)   CloseLibrary(CyberGfxBase);
  586. #ifndef __PPC__
  587.     if (Warp3DBase)     CloseLibrary(Warp3DBase);
  588. #else
  589.     if (Warp3DPPCBase)  CloseLibrary(Warp3DPPCBase);
  590. #endif
  591.  
  592. _mce_End:
  593.     CloseFont(hFont);
  594. }
  595.  
  596. // Sortir une trace formattée dans la listbox de la fenêtre trace
  597. void vTrace(LPSTR fmt, ... )
  598. {
  599.     char cBuffer[256];
  600.     va_list args;
  601.  
  602.     // Formatter la trace
  603.     va_start(args, fmt);
  604.     vsprintf(cBuffer, fmt, args);
  605.     va_end(args);
  606.  
  607.     strcat(cBuffer, "\n");
  608.  
  609.     if (bConsoleOpened)
  610.         ConPutS(cBuffer);
  611. //    else
  612.         printf(cBuffer);
  613. }
  614.  
  615. BOOL bLoadHints(void)
  616. {
  617.     FILE *hFile = fopen("gfx/w3d.hints", "r");
  618.  
  619.     if (!hFile)
  620.     {
  621.         vTrace("*** E0099 : ouverture fichier hints en lecture");
  622.         return FALSE;
  623.     }
  624.  
  625.     fread(uHint, 1, sizeof(uHint), hFile);
  626.     fclose(hFile);
  627.  
  628.     return TRUE;
  629. }
  630.  
  631. BOOL bSaveHints(void)
  632. {
  633.     FILE *hFile = fopen("gfx/w3d.hints", "w");
  634.  
  635.     if (!hFile)
  636.     {
  637.         vTrace("*** E0100 : ouverture fichier hints en écriture");
  638.         return FALSE;
  639.     }
  640.  
  641.     fwrite(uHint, 1, sizeof(uHint), hFile);
  642.     fclose(hFile);
  643.  
  644.     return TRUE;
  645. }
  646.  
  647. void DestroyWindow(HWND hWnd)
  648. {
  649.     PostMessage(hWnd, WM_DESTROY, 0, 0);
  650. }
  651.  
  652. // Gestion du clipping fenêtres
  653. struct Region *ClipWindow(HWND hWnd, LONG lMinX, LONG lMinY, LONG lMaxX, LONG lMaxY)
  654. {
  655.     struct Region *hRNew;
  656.     struct Rectangle rRect;
  657.  
  658.     rRect.MinX = lMinX;
  659.     rRect.MinY = lMinY;
  660.     rRect.MaxX = lMaxX;
  661.     rRect.MaxY = lMaxY;
  662.  
  663.     hRNew = NewRegion();
  664.     OrRectRegion(hRNew, &rRect);
  665.  
  666.     return InstallClipRegion(hWnd -> WLayer, hRNew);
  667. }
  668.  
  669. void UnclipWindow(HWND hWnd)
  670. {
  671.     register struct Region *hROld;
  672.  
  673.     if (hROld = InstallClipRegion(hWnd -> WLayer, NULL))
  674.         DisposeRegion(hROld);
  675. }
  676.  
  677. struct RastPort *GetDC(HWND hWnd)
  678. {
  679.     return hWnd -> RPort;
  680. }
  681.  
  682. BOOL ExtTextOut(HDC hdc,int X,int Y, int fuOptions, RECT *lprc, char *lpString, int cbCount, int *lpDx)
  683. {
  684.     Move(hdc, X, Y + 24);
  685.     Text(hdc, lpString, cbCount);
  686.     return TRUE;
  687. }
  688.  
  689. BOOL PtInRect(RECT *rRect, POINT pPoint)
  690. {
  691.     if (pPoint.x > rRect -> right)  return FALSE;
  692.     if (pPoint.x < rRect -> left)   return FALSE;
  693.     if (pPoint.y > rRect -> bottom) return FALSE;
  694.     if (pPoint.y < rRect -> top)    return FALSE;
  695.     return TRUE;
  696. }
  697.  
  698. // Récupérer le rectangle complet de la zone client de la fenêtre
  699. void GetClientRect(HWND hWnd, RECT *rRect)
  700. {
  701.     rRect -> left   = hWnd -> BorderLeft;
  702.     rRect -> right  = hWnd -> Width - hWnd -> BorderRight - 1;
  703.     rRect -> top    = hWnd -> BorderTop;
  704.     rRect -> bottom = hWnd -> Height - hWnd -> BorderBottom - 1;
  705. }
  706.  
  707. // Cloner un rectangle (r1 <- r2)
  708. void CopyRect(RECT *rR1, RECT *rR2)
  709. {
  710.     *rR1 = *rR2;
  711. }
  712.  
  713. // Enfler un rectangle
  714. void InflateRect(RECT *rRect, int iX, int iY)
  715. {
  716.     rRect -> left   -= iX;
  717.     rRect -> right  += iX;
  718.     rRect -> top    -= iY;
  719.     rRect -> bottom += iY;
  720. }
  721.  
  722. // Définir un rectangle (x / y / lagreur / hauteur)
  723. void SetRect(RECT *rRect, int x, int y, int w, int h)
  724. {
  725.     rRect -> left   = x;
  726.     rRect -> right  = x + w;
  727.     rRect -> top    = y;
  728.     rRect -> bottom = y + h;
  729. }
  730.  
  731. static BOOL CheckItem(MenuItem *hMI, int iId, int iState)
  732. {
  733.     if (!hMI) return FALSE;
  734.  
  735.     if (GTMENUITEM_USERDATA(hMI) == (APTR) iId)
  736.     {
  737.         if (iState & MF_CHECKED)
  738.             hMI -> Flags |= CHECKED;
  739.         else
  740.             hMI -> Flags &= ~CHECKED;
  741.         return TRUE;
  742.     }
  743.  
  744.     if (hMI -> SubItem && CheckItem(hMI -> SubItem, iId, iState))
  745.             return TRUE;
  746.  
  747.     return CheckItem(hMI -> NextItem, iId, iState);
  748. }
  749.  
  750. static BOOL CheckMenu(HMENU hMenu, int iId, int iState)
  751. {
  752.     if (!hMenu) return FALSE;
  753.  
  754.     if (hMenu -> FirstItem && CheckItem(hMenu -> FirstItem, iId, iState))
  755.         return TRUE;
  756.  
  757.     return CheckMenu(hMenu -> NextMenu, iId, iState);
  758. }
  759.  
  760. void CheckMenuItem(HMENU hMenu, int iId, int iState)
  761. {
  762.     CheckMenu(hMenu, iId, iState);
  763. }
  764.  
  765. HMENU GetMenu(HWND hWnd)
  766. {
  767.     return hWnd -> MenuStrip;
  768. }
  769.  
  770. BOOL bPrepareGadgets(void)
  771. {
  772.     if (!(gAddPoint.hIcon   = GetDiskObjectNew("gfx/BTN_ADD_POINT")))       return FALSE;
  773.     if (!(gCenter.hIcon        = GetDiskObjectNew("gfx/BTN_CENTER")))          return FALSE;
  774.     if (!(gGoDown.hIcon        = GetDiskObjectNew("gfx/BTN_GO_DOWN")))         return FALSE;
  775.     if (!(gGoLeft.hIcon        = GetDiskObjectNew("gfx/BTN_GO_LEFT")))         return FALSE;
  776.     if (!(gGoUp.hIcon        = GetDiskObjectNew("gfx/BTN_GO_UP")))           return FALSE;
  777.     if (!(gGoRight.hIcon    = GetDiskObjectNew("gfx/BTN_GO_RIGHT")))        return FALSE;
  778.     if (!(gGrab.hIcon        = GetDiskObjectNew("gfx/BTN_GRABBER")))         return FALSE;
  779.     if (!(gMakeTri.hIcon    = GetDiskObjectNew("gfx/BTN_MAKE_TRIANGLE")))   return FALSE;
  780.     if (!(gReverse.hIcon    = GetDiskObjectNew("gfx/BTN_REVERSE")))         return FALSE;
  781.     if (!(gRotAnti.hIcon    = GetDiskObjectNew("gfx/BTN_ROTATE_TRIGO")))    return FALSE;
  782.     if (!(gRotClock.hIcon   = GetDiskObjectNew("gfx/BTN_ROTATE_CLOCK")))    return FALSE;
  783.     if (!(gZoomIn.hIcon        = GetDiskObjectNew("gfx/BTN_ZOOM_IN")))         return FALSE;
  784.     if (!(gZoomOut.hIcon    = GetDiskObjectNew("gfx/BTN_ZOOM_OUT")))        return FALSE;
  785.  
  786.     return TRUE;
  787. }
  788.  
  789. void vEraseGadgets(void)
  790. {
  791.     if (gAddPoint.hIcon)FreeDiskObject(gAddPoint.hIcon);
  792.     if (gCenter.hIcon)  FreeDiskObject(gCenter.hIcon);
  793.     if (gGoDown.hIcon)  FreeDiskObject(gGoDown.hIcon);
  794.     if (gGoLeft.hIcon)  FreeDiskObject(gGoLeft.hIcon);
  795.     if (gGoUp.hIcon)    FreeDiskObject(gGoUp.hIcon);
  796.     if (gGoRight.hIcon) FreeDiskObject(gGoRight.hIcon);
  797.     if (gGrab.hIcon)    FreeDiskObject(gGrab.hIcon);
  798.     if (gMakeTri.hIcon) FreeDiskObject(gMakeTri.hIcon);
  799.     if (gReverse.hIcon) FreeDiskObject(gReverse.hIcon);
  800.     if (gRotAnti.hIcon) FreeDiskObject(gRotAnti.hIcon);
  801.     if (gRotClock.hIcon)FreeDiskObject(gRotClock.hIcon);
  802.     if (gZoomIn.hIcon)  FreeDiskObject(gZoomIn.hIcon);
  803.     if (gZoomOut.hIcon) FreeDiskObject(gZoomOut.hIcon);
  804. }
  805.  
  806. HGDIOBJ hAddImage(HWND hWnd, char *sName, int iX, int iY, int iWidth, int iHeight)
  807. {
  808.     HGDIOBJ hObject = NewDTObject(sName,
  809.         DTA_SourceType,        DTST_FILE,
  810.         GA_RelVerify,        TRUE,
  811.           GA_Immediate,       TRUE,
  812.         GA_Left,            iX,
  813.           GA_Top,                iY,
  814.         GA_Width,           iWidth,
  815.         GA_Height,          iHeight,
  816.         ICA_TARGET,            ICTARGET_IDCMP,
  817.         TAG_DONE);
  818.  
  819.     if (!hObject)
  820.         return NULL;
  821.  
  822.     AddDTObject(hWnd, NULL, hObject, -1);
  823.     return hObject;
  824. }
  825.  
  826. void vMoveImage(HWND hWnd, HGDIOBJ hObject, int iX, int iY)
  827. {
  828.     RemoveDTObject(hWnd, hObject);
  829.     SetDTAttrs(hObject, hWnd, NULL,
  830.         GA_Left,            iX,
  831.           GA_Top,                iY,
  832.         TAG_DONE);
  833.     AddDTObject(hWnd, NULL, hObject, -1);
  834. }
  835.  
  836. void vRefreshImage(HWND hWnd, HGDIOBJ hObject)
  837. {
  838.     RefreshDTObjectA(hObject, hWnd, NULL, NULL);
  839. }
  840.  
  841. void vRemoveImage(HWND hWnd, HGDIOBJ hObject)
  842. {
  843.     RemoveDTObject(hWnd, hObject);
  844.     DisposeDTObject(hObject);
  845. }
  846.  
  847. //###############################################################################
  848. // Protos non mappés
  849. void vAddTextOutline(void)
  850. {
  851. }
  852.  
  853. DWORD GetTickCount(void)
  854. {
  855.     return (DWORD) 0;
  856. }
  857.  
  858. void ShowWindow(HWND hWnd, int iI)
  859. {
  860. }     
  861.  
  862. void PostQuitMessage(int iI)
  863. {
  864. }
  865.  
  866.  
  867.